home *** CD-ROM | disk | FTP | other *** search
/ Aminet 6 / Aminet 6 - June 1995.iso / Aminet / gfx / 3d / irit50src.lha / irit5 / irit / inptevl1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-15  |  41.0 KB  |  1,015 lines
  1. /*****************************************************************************
  2. *   "Irit" - the 3d (not only polygonal) solid modeller.             *
  3. *                                         *
  4. * Written by:  Gershon Elber                Ver 0.2, Mar. 1990   *
  5. ******************************************************************************
  6. *   Module to evaluate the binary tree generated by the InptPrsr module.     *
  7. *   All the objects are handled the same but the numerical one, which is     *
  8. * moved as a RealType and not as an object (only internally within this         *
  9. * module) as it is frequently used and consumes much less memory this way.   *
  10. *   Note this module is par of InptPrsr module and was splited only because  *
  11. * of text file sizes problems...                         *
  12. *****************************************************************************/
  13.  
  14. #include <stdio.h>
  15. #include <ctype.h>
  16. #include <math.h>
  17. #include <string.h>
  18. #include "program.h"
  19. #include "allocate.h"
  20. #include "attribut.h"
  21. #include "convex.h"
  22. #include "ctrl-brk.h"
  23. #include "dosintr.h"
  24. #include "freeform.h"
  25. #include "geomat3d.h"
  26. #include "geomvals.h"
  27. #include "inptprsg.h"
  28. #include "inptprsl.h"
  29. #include "objects.h"
  30. #include "overload.h"
  31. #include "primitiv.h"
  32. #include "windows.h"
  33. #include "iritgrap.h"
  34.  
  35. /*   I prefer to put the declarations of static functions just before the    */
  36. /* function themselves, but the tables below needs them so...             */
  37.  
  38. /* Although the type of parameters is specified (for InptPrsrTypeCheck rtn)  */
  39. /* All the parameters to the following dispatched functions are passed by    */
  40. /* address. There is a problem in TurboC (ANSI C?) that all the real types   */
  41. /* are passed as double, even if the are float. As RealType may be float,    */
  42. /* the problems is hidden by passing parameters by address...             */
  43.  
  44. NumFuncTableType NumFuncTable[] = {
  45.     { "ACOS",     ARCCOS,acos,        1,    { NUMERIC_EXPR } },
  46.     { "ASIN",     ARCSIN,asin,        1,    { NUMERIC_EXPR } },
  47.     { "ATAN2",     ARCTAN2,atan2,        2,    { NUMERIC_EXPR, NUMERIC_EXPR } },
  48.     { "ATAN",     ARCTAN,atan,        1,    { NUMERIC_EXPR } },
  49.     { "COS",     COS,    cos,        1,    { NUMERIC_EXPR } },
  50.     { "EXP",     EXP,    exp,        1,    { NUMERIC_EXPR } },
  51.     { "ABS",     FABS,    fabs,        1,    { NUMERIC_EXPR } },
  52.     { "LN",     LN,    log,        1,    { NUMERIC_EXPR } },
  53.     { "LOG",     LOG,    log10,        1,    { NUMERIC_EXPR } },
  54.     { "SIN",     SIN,    sin,        1,    { NUMERIC_EXPR } },
  55.     { "SQRT",     SQRT,    sqrt,        1,    { NUMERIC_EXPR } },
  56.     { "TAN",     TAN,    tan,        1,    { NUMERIC_EXPR } },
  57.     { "CPOLY",     CPOLY,    PolyCountPolys,    1,    { POLY_EXPR } },
  58.     { "AREA",     AREA,    PolyObjectArea,    1,    { POLY_EXPR } },
  59.     { "VOLUME",  VOLUME,PolyObjectVolume,1,     { POLY_EXPR } },
  60.     { "TIME",     TIME,    DosGetTime,    1,    { NUMERIC_EXPR } },
  61.     { "SIZEOF",  SIZEOF,GetObjectSize,    1,    { OLST_EXPR | POLY_EXPR | CURVE_EXPR } },
  62.     { "MESHSIZE",MESHSIZE,GetMeshSize,    2,    { SURFACE_EXPR, NUMERIC_EXPR } },
  63.     { "THISOBJ", THISOBJ,ThisObjectIs,    1,    { STRING_EXPR } },
  64.     { "RANDOM",  IRT_RNDM,IritRandom,    2,    { NUMERIC_EXPR, NUMERIC_EXPR } },
  65.     { "CLNTEXEC",CLNTEXEC,ClientExecute,1,    { STRING_EXPR } }
  66.  
  67. };
  68. int NumFuncTableSize = sizeof(NumFuncTable) / sizeof(NumFuncTableType);
  69.  
  70. ObjFuncTableType ObjFuncTable[] = {
  71.     { "POINT",      POINT,    GenPTObject,        3,    { NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        POINT_EXPR },
  72.     { "VECTOR",      VECTOR,    GenVECObject,        3,    { NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        VECTOR_EXPR },
  73.     { "PLANE",      PLANE,    GenPLANEObject,        4,    { NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, PLANE_EXPR },
  74.     { "CTLPT",      CTLPT,    InptEvalCtlPtFromParams, ANY_PARAM_NUM, { 0 },                        CTLPT_EXPR },
  75.     { "ROTX",      ROTX,        GMGenMatObjectRotX,    1,    { NUMERIC_EXPR },                    MATRIX_EXPR },
  76.     { "ROTY",      ROTY,        GMGenMatObjectRotY,    1,    { NUMERIC_EXPR },                    MATRIX_EXPR },
  77.     { "ROTZ",      ROTZ,        GMGenMatObjectRotZ,    1,    { NUMERIC_EXPR },                    MATRIX_EXPR },
  78.     { "TRANS",      TRANS,    GMGenMatObjectTrans,    1,    { VECTOR_EXPR },                    MATRIX_EXPR },
  79.     { "SCALE",      SCALE,    GMGenMatObjectScale,    1,    { VECTOR_EXPR },                    MATRIX_EXPR },
  80.     { "BOX",      BOX,        GenBOXObject,        4,    { VECTOR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, POLY_EXPR },
  81.     { "GBOX",      GBOX,        GenGBOXObject,        4,    { VECTOR_EXPR, VECTOR_EXPR, VECTOR_EXPR, VECTOR_EXPR }, POLY_EXPR },
  82.     { "CONE",      CONE,        GenCONEObject,        3,    { VECTOR_EXPR, VECTOR_EXPR, NUMERIC_EXPR },        POLY_EXPR },
  83.     { "CON2",      CONE2,    GenCONE2Object,        4,    { VECTOR_EXPR, VECTOR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, POLY_EXPR },
  84.     { "CYLIN",      CYLIN,    GenCYLINObject,        3,    { VECTOR_EXPR, VECTOR_EXPR, NUMERIC_EXPR },        POLY_EXPR },
  85.     { "SPHERE",      SPHERE,    GenSPHEREObject,    2,    { VECTOR_EXPR, NUMERIC_EXPR },                POLY_EXPR },
  86.     { "TORUS",      TORUS,    GenTORUSObject,        4,    { VECTOR_EXPR, VECTOR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, POLY_EXPR },
  87.     { "CIRCPOLY", CIRCPOLY,    GenPOLYDISKObject,    3,    { VECTOR_EXPR, VECTOR_EXPR, NUMERIC_EXPR },        POLY_EXPR },
  88.     { "POLY",     POLY,        GenPOLYGONObject,    2,    { OLST_EXPR, NUMERIC_EXPR },                POLY_EXPR },
  89.     { "CROSSEC",  CROSSEC,    GenCROSSECObject,    1,    { POLY_CURVE_EXPR },                    POLY_EXPR },
  90.     { "SURFREV",  SURFREV,    GenSURFREVObject,    1,    { POLY_CURVE_EXPR },                    POLY_EXPR | SURFACE_EXPR },
  91.     { "SURFPREV", SURFPREV,    GenSURFPREVObject,    1,    { CURVE_EXPR },                        SURFACE_EXPR },
  92.     { "EXTRUDE",  EXTRUDE,    GenEXTRUDEObject,    2,    { POLY_CURVE_EXPR, VECTOR_EXPR },            POLY_EXPR | SURFACE_EXPR },
  93.     { "LIST",      LIST,        InptEvalGenObjectList,    ANY_PARAM_NUM, { 0 },                        OLST_EXPR },
  94.     { "LOAD",     LOAD,        LoadObjectFromFile,    1,    { STRING_EXPR },                    ANY_EXPR },
  95.     { "CONVEX",      CONVEX,    ConvexPolyObjectN,    1,    { POLY_EXPR  | OLST_EXPR },                POLY_EXPR | OLST_EXPR },
  96.     { "SBEZIER",  SBEZIER,    GenBezierSurfaceObject, 1,    { OLST_EXPR },                        SURFACE_EXPR },
  97.     { "CBEZIER",  CBEZIER,    GenBezierCurveObject,    1,    { OLST_EXPR },                        CURVE_EXPR },
  98.     { "SBSPLINE", SBSPLINE,    GenBsplineSurfaceObject,4,    { NUMERIC_EXPR, NUMERIC_EXPR, OLST_EXPR, OLST_EXPR },    SURFACE_EXPR },
  99.     { "CBSPLINE", CBSPLINE,    GenBsplineCurveObject,    3,    { NUMERIC_EXPR, OLST_EXPR, OLST_EXPR },            CURVE_EXPR },
  100.     { "SEVAL",    SEVAL,    EvalSurfaceObject,    3,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        CTLPT_EXPR },
  101.     { "CEVAL",    CEVAL,    EvalCurveObject,    2,    { CURVE_EXPR, NUMERIC_EXPR },                CTLPT_EXPR },
  102.     { "STANGENT", STANGENT,    TangentSurfaceObject,    4,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, VECTOR_EXPR },
  103.     { "CTANGENT", CTANGENT,    TangentCurveObject,    2,    { CURVE_EXPR, NUMERIC_EXPR },                VECTOR_EXPR },
  104.     { "SNORMAL",  SNORMAL,    NormalSurfaceObject,    3,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        VECTOR_EXPR },
  105.     { "TDIVIDE",  TDIVIDE,    DivideTrivarObject,    3,    { TRIVAR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        OLST_EXPR },
  106.     { "SDIVIDE",  SDIVIDE,    DivideSurfaceObject,    3,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        OLST_EXPR },
  107.     { "CDIVIDE",  CDIVIDE,    DivideCurveObject,    2,    { CURVE_EXPR, NUMERIC_EXPR },                OLST_EXPR },
  108.     { "TREGION",  TREGION,    RegionFromTrivarObject, 4,    { TRIVAR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, SURFACE_EXPR },
  109.     { "SREGION",  SREGION,    RegionFromSurfaceObject,4,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, SURFACE_EXPR },
  110.     { "CREGION",  CREGION,    RegionFromCurveObject,    3,    { CURVE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        CURVE_EXPR },
  111.     { "TREFINE",  TREFINE,    RefineTrivarObject,    4,    { TRIVAR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, OLST_EXPR }, SURFACE_EXPR },
  112.     { "SREFINE",  SREFINE,    RefineSurfaceObject,    4,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, OLST_EXPR }, SURFACE_EXPR },
  113.     { "CREFINE",  CREFINE,    RefineCurveObject,    3,    { CURVE_EXPR, NUMERIC_EXPR, OLST_EXPR },        CURVE_EXPR },
  114.     { "SRAISE",   SRAISE,    RaiseSurfaceObject,    3,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        SURFACE_EXPR },
  115.     { "CRAISE",   CRAISE,    RaiseCurveObject,    2,    { CURVE_EXPR, NUMERIC_EXPR },                CURVE_EXPR },
  116.     { "CSURFACE", CSURFACE,    CurveFromSurface,    3,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        CURVE_EXPR },
  117.     { "CMESH",    CMESH,    CurveFromSrfMesh,    3,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        CURVE_EXPR },
  118.     { "NTH",      NTH,        GetNthList,        2,    { OLST_EXPR, NUMERIC_EXPR },                ANY_EXPR },
  119.     { "GPOLYGON", GPOLYGON,    Geometry2Polygons,    2,    { OLST_GEOM_EXPR, NUMERIC_EXPR },            POLY_EXPR },
  120.     { "GPOLYLINE",GPOLYLINE,    Geometry2Polylines,    2,    { OLST_GEOM_EXPR, NUMERIC_EXPR },            POLY_EXPR },
  121.     { "CIRCLE",   CIRCLE,    GenCircleCurveObject,    2,    { VECTOR_EXPR, NUMERIC_EXPR },                CURVE_EXPR },
  122.     { "PCIRCLE",  PCIRCLE,    GenPCircleCurveObject,    2,    { VECTOR_EXPR, NUMERIC_EXPR },                CURVE_EXPR },
  123.     { "ARC",      ARC,        GenArcCurveObject,    3,    { VECTOR_EXPR, VECTOR_EXPR, VECTOR_EXPR },        CURVE_EXPR },
  124.     { "RULEDSRF", RULEDSRF,    GenRuledSrfObject,    2,    { CURVE_EXPR, CURVE_EXPR },                SURFACE_EXPR },
  125.     { "BOOLSUM",  BOOLSUM,    GenBoolSumSrfObject,    4,    { CURVE_EXPR, CURVE_EXPR, CURVE_EXPR, CURVE_EXPR },    SURFACE_EXPR },
  126.     { "BOOLONE",  BOOLONE,    GenBoolOneSrfObject,    1,    { CURVE_EXPR },                        SURFACE_EXPR },
  127.     { "SFROMCRVS", SFROMCRVS,    GenSrfFromCrvsObject,    2,    { OLST_EXPR, NUMERIC_EXPR },                SURFACE_EXPR },
  128.     { "SWEEPSRF", SWEEPSRF,    GenSweepSrfObject,    3,    { CURVE_EXPR, CURVE_EXPR, CURVE_EXPR | VECTOR_EXPR | NUMERIC_EXPR },    SURFACE_EXPR },
  129.     { "SWPSCLSRF", SWPSCLSRF,    GenSweepScaleSrfObject,    5,    { CURVE_EXPR, CURVE_EXPR, CURVE_EXPR | NUMERIC_EXPR, CURVE_EXPR | VECTOR_EXPR | NUMERIC_EXPR, NUMERIC_EXPR },    SURFACE_EXPR },
  130.     { "OFFSET",      OFFSET,    GenOffsetObject,    4,    { CURVE_EXPR | SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, CURVE_EXPR | SURFACE_EXPR },
  131.     { "AOFFSET",  AOFFSET,    GenAOffsetObject,    5,    { CURVE_EXPR | SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, CURVE_EXPR | SURFACE_EXPR | OLST_EXPR },
  132.     { "LOFFSET",  LOFFSET,    GenLeastSqrOffsetObject,5,    { CURVE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, CURVE_EXPR },
  133.     { "COERCE",   COERCE,    CoerceObjectTo,        2,    { ANY_EXPR, NUMERIC_EXPR },                ANY_EXPR },
  134.     { "CEDITPT",  CEDITPT,    EditCrvControlPoint,    3,    { CURVE_EXPR, CTLPT_EXPR, NUMERIC_EXPR },        CURVE_EXPR },
  135.     { "SEDITPT",  SEDITPT,    EditSrfControlPoint,    4,    { SURFACE_EXPR, CTLPT_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, SURFACE_EXPR },
  136.     { "MERGEPOLY",MERGEPOLY,    GenObjectFromPolyList,    1,    { OLST_EXPR },                        POLY_EXPR },
  137.     { "CMORPH",   CMORPH,    TwoCrvsMorphing,    4,    { CURVE_EXPR, CURVE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },    CURVE_EXPR | OLST_EXPR },
  138.     { "SMORPH",   SMORPH,    TwoSrfsMorphing,    3,    { SURFACE_EXPR, SURFACE_EXPR, NUMERIC_EXPR },        SURFACE_EXPR },
  139.     { "BZR2BSP",  BZR2BSP,    CnvrtBezierToBspline,    1,    { SURFACE_EXPR | CURVE_EXPR },                CURVE_EXPR | SURFACE_EXPR },
  140.     { "BSP2BZR",  BSP2BZR,    CnvrtBsplineToBezier,    1,    { SURFACE_EXPR | CURVE_EXPR },                CURVE_EXPR | SURFACE_EXPR },
  141.     { "SMERGE",   SMERGE,    MergeSrfSrf,        4,    { SURFACE_EXPR, SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, SURFACE_EXPR },
  142.     { "CDERIVE",  CDERIVE,    DeriveCurveObject,    1,    { CURVE_EXPR },                        CURVE_EXPR },
  143.     { "SDERIVE",  SDERIVE,    DeriveSurfaceObject,    2,    { SURFACE_EXPR, NUMERIC_EXPR },                SURFACE_EXPR },
  144.     { "TDERIVE",  TDERIVE,    DeriveTrivarObject,    2,    { TRIVAR_EXPR, NUMERIC_EXPR },                TRIVAR_EXPR },
  145.     { "CINTEG",   CINTEG,    IntegrateCurveObject,    1,    { CURVE_EXPR },                        CURVE_EXPR },
  146.     { "SNRMLSRF", SNRMLSRF,    SurfaceNormalObject,    1,    { SURFACE_EXPR },                    SURFACE_EXPR },
  147.     { "SYMBPROD", SYMBPROD,    TwoCrvsSrfsProduct,    2,    { CURVE_EXPR | SURFACE_EXPR, CURVE_EXPR | SURFACE_EXPR }, CURVE_EXPR | SURFACE_EXPR },
  148.     { "SYMBDPROD",SYMBDPROD,    TwoCrvsSrfsDotProduct,    2,    { CURVE_EXPR | SURFACE_EXPR, CURVE_EXPR | SURFACE_EXPR }, CURVE_EXPR | SURFACE_EXPR },
  149.     { "SYMBCPROD",SYMBCPROD,    TwoCrvsSrfsCrossProduct,2,    { CURVE_EXPR | SURFACE_EXPR, CURVE_EXPR | SURFACE_EXPR }, CURVE_EXPR | SURFACE_EXPR },
  150.     { "SYMBSUM",  SYMBSUM,    TwoCrvsSrfsSum,        2,    { CURVE_EXPR | SURFACE_EXPR, CURVE_EXPR | SURFACE_EXPR }, CURVE_EXPR | SURFACE_EXPR },
  151.     { "SYMBDIFF", SYMBDIFF,    TwoCrvsSrfsDiff,    2,    { CURVE_EXPR | SURFACE_EXPR, CURVE_EXPR | SURFACE_EXPR }, CURVE_EXPR | SURFACE_EXPR },
  152.     { "HOMOMAT",  HOMOMAT,    GenMatObjectGeneric,    1,    { OLST_EXPR },                        MATRIX_EXPR },
  153.     { "CINFLECT", CINFLECT,    CrvInflectionPts,    2,    { CURVE_EXPR, NUMERIC_EXPR },                CURVE_EXPR | OLST_EXPR },
  154.     { "CCRVTR",   CCRVTR,    CrvCurvaturePts,    2,    { CURVE_EXPR, NUMERIC_EXPR },                CURVE_EXPR | OLST_EXPR },
  155.     { "SCRVTR",   SCRVTR,    SrfCurvatureBounds,    3,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        SURFACE_EXPR },
  156.     { "CREPARAM", CREPARAM,    CrvReparametrization,    3,    { CURVE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        CURVE_EXPR },
  157.     { "SREPARAM", SREPARAM,    SrfReparametrization,    4,    { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, SURFACE_EXPR },
  158.     { "CEVOLUTE", CEVOLUTE,    CrvEvolute,        1,    { CURVE_EXPR },                        CURVE_EXPR },
  159.     { "CZEROS",   CZEROS,    CrvZeros,        3,    { CURVE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        OLST_EXPR },
  160.     { "CEXTREMES",CEXTREMES,    CrvExtremes,        3,    { CURVE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        OLST_EXPR },
  161.     { "CCINTER",  CCINTER,    CrvCrvInter,        4,    { CURVE_EXPR, CURVE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },    SURFACE_EXPR | OLST_EXPR },
  162.     { "NIL",      NIL,            GetNilList,        0,     { 0 },                            OLST_EXPR },
  163.     { "COORD",    COORD,        GetObjectCoord,        2,     { ANY_EXPR, NUMERIC_EXPR },                NUMERIC_EXPR | CTLPT_EXPR | POINT_EXPR },
  164.     { "COMPOSE",  COMPOSE,      CrvComposition,        2,     { CURVE_EXPR | SURFACE_EXPR, CURVE_EXPR },        CURVE_EXPR },
  165.     { "PRISA",    PRISA,        SrfsPrisa,        5,     { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, VECTOR_EXPR }, OLST_EXPR },
  166.     { "CRVPTDST", CRVPTDIST,    CrvPointDist,        4,     { CURVE_EXPR, POINT_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },    NUMERIC_EXPR | OLST_EXPR },
  167.     { "CRVLNDST", CRVLNDIST,    CrvLineDist,        5,     { CURVE_EXPR, POINT_EXPR, VECTOR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },      NUMERIC_EXPR | OLST_EXPR },
  168.     { "ADAPISO",  ADAPISO,      SrfAdapIsoCurves,    5,     { SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, OLST_EXPR | CURVE_EXPR },
  169.     { "PDOMAIN",  PDOMAIN,    GetFreefromParamDomain,    1,    { TRIVAR_EXPR | TRIMSRF_EXPR | SURFACE_EXPR | CURVE_EXPR }, OLST_EXPR },
  170.     { "CINTERP",  CINTERP,    CrvLeastSquarePtData,    4,    { OLST_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, CURVE_EXPR },
  171.     { "SINTERP",  SINTERP,    SrfLeastSquarePtData,    6,    { OLST_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR }, SURFACE_EXPR },
  172.     { "CMULTIRES",CMULTIRES,    CurveMultiResDecomp,    2,    { CURVE_EXPR, NUMERIC_EXPR },                OLST_EXPR },
  173.     { "GETLINE",  GETLINE,    WndwInputStdinObject,    1,    { NUMERIC_EXPR },                    ANY_EXPR },
  174.     { "FFEXTREME",FFEXTREME,    ExtremumControlPointVals,2,    { CURVE_EXPR | SURFACE_EXPR, NUMERIC_EXPR },        CTLPT_EXPR },
  175.     { "TRIMSRF",  TRIMSRF,      GenTrimmedSurface,      3,      { SURFACE_EXPR, CURVE_EXPR | OLST_EXPR, NUMERIC_EXPR },    TRIMSRF_EXPR },
  176.     { "STRIMSRF", SRFTRIMSRF,   GetSrfFromTrimmedSrf,   1,      { TRIMSRF_EXPR },                    SURFACE_EXPR },
  177.     { "CTRIMSRF", CRVTRIMCRV,   GetTrimCrvsFromTrimmedSrf,2,    { TRIMSRF_EXPR, NUMERIC_EXPR },                OLST_EXPR },
  178.     { "TBEZIER",  TBEZIER,      GenBezierTrivarObject,  1,    { OLST_EXPR },                        TRIVAR_EXPR },
  179.     { "TBSPLINE", TBSPLINE,     GenBsplineTrivarObject, 5,    { NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, OLST_EXPR, OLST_EXPR },    TRIVAR_EXPR },
  180.     { "TEVAL",    TEVAL,        EvalTrivarObject,    4,    { TRIVAR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        CTLPT_EXPR },
  181.     { "STRIVAR",  STRIVAR,    SurfaceFromTrivar,    3,    { TRIVAR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR },        SURFACE_EXPR },
  182.     { "TINTERP",  TINTERP,    InterpolateTrivar,    1,    { TRIVAR_EXPR },                    TRIVAR_EXPR },
  183.     { "CLNTREAD", CLNTREAD,    ClientRead,        2,    { NUMERIC_EXPR, NUMERIC_EXPR },                ANY_EXPR },
  184.     { "MOMENT",   MOMENT,    ComputeCrvMoments,    2,    { CURVE_EXPR, NUMERIC_EXPR },                POINT_EXPR | VECTOR_EXPR },
  185.     { "TFROMSRFS",TFROMSRFS,    GenTVFromSrfsObject,    2,    { OLST_EXPR, NUMERIC_EXPR },                TRIVAR_EXPR },
  186. };
  187. int ObjFuncTableSize = sizeof(ObjFuncTable) / sizeof(ObjFuncTableType);
  188.  
  189. /* The cast for DosSystem below is because of the xlc compiler for the R6000 */
  190. /* aix system complains on DosSystem as function with no arguments, so we    */
  191. /* make it think it has one integer argument...                     */
  192. GenFuncTableType GenFuncTable[] = {
  193.     { "EXIT",    EXIT,        IritExit0,        0,    { 0 } },
  194.     { "VIEWOBJ",VIEWOBJ,    WndwViewObject,        1,    { ANY_EXPR } },
  195.     { "CHDIR",    CHDIR,        DosChangeDir,        1,    { STRING_EXPR } },
  196.     { "INCLUDE",INCLUDE,    FileInclude,        1,    { STRING_EXPR } },
  197.     { "SAVE",    SAVE,        SaveObjectInFile,    2,    { STRING_EXPR, ANY_EXPR } },
  198.     { "FREE",    FREEOBJ,    FreeObject,        1,    { ANY_EXPR } },
  199.     { "IF",    IFCOND,     InptEvalIfCondition,    ANY_PARAM_NUM, { 0 } },
  200.     { "FOR",    FORLOOP,     InptEvalForLoop,    4,    { NUMERIC_EXPR,    NUMERIC_EXPR, NUMERIC_EXPR, ANY_EXPR } },
  201.     { "HELP",    PRHELP,        InptEvalPrintHelp,    1,    { STRING_EXPR } },
  202.     { "VARLIST", VARLIST,     PrintObjectList,    0,    { 0 } },
  203.     { "SYSTEM",    SYSTEM,        DosSystem,        1,    { STRING_EXPR } },
  204.     { "LOGFILE",LOGFILE,     WndwLogPrint,        1,    { STRING_EXPR | NUMERIC_EXPR } },
  205.     { "COLOR",    COLOR,        AttrSetObjectColor,     2,    { OLST_GEOM_EXPR, NUMERIC_EXPR } },
  206.     { "SNOC",    SNOC,        SnocList,        2,    { ANY_EXPR, OLST_EXPR } },
  207.     { "ATTRIB",    ATTRIB,        SetObjectAttrib,    3,    { ANY_EXPR, STRING_EXPR, ANY_EXPR } },
  208.     { "RMATTR",    RMATTR,        RemoveObjectAttrib,    2,    { ANY_EXPR, STRING_EXPR } },
  209.     { "FFCOMPAT",FFCOMPAT,    MakeFreeFormCompatible,    2,    { CURVE_EXPR | SURFACE_EXPR, CURVE_EXPR | SURFACE_EXPR } },
  210.     { "MSLEEP",  MSLEEP,    MilisecondSleep,    1,    { NUMERIC_EXPR } },
  211.     { "PRINTF", IRITPRINT,    IritObjectPrintfStdout,    2,    { STRING_EXPR, OLST_EXPR } },
  212.     { "IRITSTATE",IRITSTATE,    SetIritState,        2,    { STRING_EXPR, NUMERIC_EXPR | STRING_EXPR } },
  213.     { "ERROR",  IRITERROR,      IritPrsrFatalError,    1,    { STRING_EXPR } },
  214.     { "CLNTWRITE",CLNTWRITE,    ClientWrite,        2,    { NUMERIC_EXPR, ANY_EXPR } },
  215.     { "CLNTCLOSE",CLNTCLOSE,    ClientClose,        2,    { NUMERIC_EXPR, NUMERIC_EXPR } }
  216. };
  217. int GenFuncTableSize = sizeof(GenFuncTable) / sizeof(GenFuncTableType);
  218.  
  219. ConstantTableType ConstantTable[] = {
  220.     { "PI",    M_PI },
  221.  
  222.     { "ON",    1.0 },
  223.     { "TRUE",    1.0 },
  224.     { "OFF",    0.0 },
  225.     { "FALSE",    0.0 },
  226.  
  227.     { "COL",    (double) CAGD_CONST_U_DIR },
  228.     { "ROW",    (double) CAGD_CONST_V_DIR },
  229.     { "DEPTH",  (double) TRIV_CONST_W_DIR },
  230.  
  231.     { "KV_OPEN", (double) KV_UNIFORM_OPEN },
  232.     { "KV_FLOAT", (double) KV_UNIFORM_FLOAT },
  233.     { "KV_PERIODIC", (double) KV_UNIFORM_PERIODIC },
  234.  
  235.     { "PARAM_CHORD", (double) CAGD_CHORD_LEN_PARAM },
  236.     { "PARAM_CENTRIP", (double) CAGD_CENTRIPETAL_PARAM },
  237.     { "PARAM_UNIFORM", (double) CAGD_UNIFORM_PARAM },
  238.  
  239.     { "E1", (double) CAGD_PT_E1_TYPE },
  240.     { "E2", (double) CAGD_PT_E2_TYPE },
  241.     { "E3", (double) CAGD_PT_E3_TYPE },
  242.     { "E4", (double) CAGD_PT_E4_TYPE },
  243.     { "E5", (double) CAGD_PT_E5_TYPE },
  244.  
  245.     { "P1", (double) CAGD_PT_P1_TYPE },
  246.     { "P2", (double) CAGD_PT_P2_TYPE },
  247.     { "P3", (double) CAGD_PT_P3_TYPE },
  248.     { "P4", (double) CAGD_PT_P4_TYPE },
  249.     { "P5", (double) CAGD_PT_P5_TYPE },
  250.  
  251.     { "UNDEF_TYPE",   (double) IP_OBJ_UNDEF },
  252.     { "POLY_TYPE",    (double) IP_OBJ_POLY },
  253.     { "NUMERIC_TYPE", (double) IP_OBJ_NUMERIC },
  254.     { "POINT_TYPE",   (double) IP_OBJ_POINT },
  255.     { "VECTOR_TYPE",  (double) IP_OBJ_VECTOR },
  256.     { "PLANE_TYPE",   (double) IP_OBJ_PLANE },
  257.     { "MATRIX_TYPE",  (double) IP_OBJ_MATRIX },
  258.     { "CURVE_TYPE",   (double) IP_OBJ_CURVE },
  259.     { "SURFACE_TYPE", (double) IP_OBJ_SURFACE },
  260.     { "STRING_TYPE",  (double) IP_OBJ_STRING },
  261.     { "CTLPT_TYPE",   (double) IP_OBJ_CTLPT },
  262.     { "LIST_TYPE",    (double) IP_OBJ_LIST_OBJ },
  263.     { "TRIVAR_TYPE",  (double) IP_OBJ_TRIVAR },
  264.     { "TRIMSRF_TYPE", (double) IP_OBJ_TRIMSRF },
  265.  
  266.     { "BLACK",  (double) IG_IRIT_BLACK },
  267.     { "BLUE",    (double) IG_IRIT_BLUE },
  268.     { "GREEN",    (double) IG_IRIT_GREEN },
  269.     { "CYAN",    (double) IG_IRIT_CYAN },
  270.     { "RED",    (double) IG_IRIT_RED },
  271.     { "MAGENTA",(double) IG_IRIT_MAGENTA },
  272.     { "YELLOW", (double) IG_IRIT_YELLOW },
  273.     { "WHITE",  (double) IG_IRIT_WHITE },
  274.  
  275.     { "MSDOS",  (double) MACHINE_MSDOS },
  276.     { "SGI",    (double) MACHINE_SGI },
  277.     { "HP",     (double) MACHINE_HP },
  278.     { "SUN",    (double) MACHINE_SUN },
  279.     { "APOLLO", (double) MACHINE_APOLLO },
  280.     { "UNIX",   (double) MACHINE_UNIX },
  281.     { "IBMOS2", (double) MACHINE_IBMOS2 },
  282.     { "IBMNT",  (double) MACHINE_IBMNT },
  283.     { "AMIGA",  (double) MACHINE_AMIGA },
  284. };
  285. int ConstantTableSize = sizeof(ConstantTable) / sizeof(ConstantTableType);
  286.  
  287. UserDefinedFuncDefType
  288.     *UserDefinedFuncList = NULL;
  289.  
  290. /*****************************************************************************
  291. * DESCRIPTION:                                                               M
  292. * Do type checking to the given parsed tree - return type if found one       M
  293. * or returns ERROR_EXPR if error in types was detected.                 M
  294. *                                                                            *
  295. * PARAMETERS:                                                                M
  296. *   Root:      Of parse tree to verify.                                      M
  297. *   Level:     Of recursion. Used to identify top level (Level == 0).        M
  298. *                                                                            *
  299. * RETURN VALUE:                                                              M
  300. *   IritExprType:  ERROR_EXPR if found error, or expression type otherwise.  M
  301. *                                                                            *
  302. * KEYWORDS:                                                                  M
  303. *   InptPrsrTypeCheck                                                        M
  304. *****************************************************************************/
  305. IritExprType InptPrsrTypeCheck(ParseTree *Root, int Level)
  306. {
  307.     IritExprType Right, Left, Result;
  308.  
  309.     if (IS_NUM_FUNCTION(Root -> NodeKind)) {   /* Funcs returning Real Type: */
  310.     if (IritEvalFuncParamMismatch(Root))
  311.         return ERROR_EXPR;
  312.     return NUMERIC_EXPR;
  313.     }
  314.  
  315.     if (IS_GEN_FUNCTION(Root -> NodeKind)) {     /* Funcs returning nothing: */
  316.     if (Level == 0) {
  317.         if (IritEvalFuncParamMismatch(Root))
  318.         return ERROR_EXPR;
  319.         return NO_EXPR;
  320.     }
  321.     else {
  322.         IPGlblEvalError = IE_ERR_TYPE_MISMATCH;
  323.         UpdateCharError("Procedure ", Root -> NodeKind, Root);
  324.         return ERROR_EXPR;
  325.     }
  326.     }
  327.  
  328.     if (IS_OBJ_FUNCTION(Root -> NodeKind)) {     /* Funcs returning objects: */
  329.     if (IritEvalFuncParamMismatch(Root))
  330.         return ERROR_EXPR;
  331.     return ObjFuncTable[Root -> NodeKind - OBJ_FUNC_OFFSET].RetType;
  332.     }
  333.  
  334.     switch (Root -> NodeKind) {
  335.     case PLUS:
  336.     case MINUS:
  337.     case MULT:
  338.     case DIV:
  339.     case POWER:
  340.         Right = InptPrsrTypeCheck(Root -> Right, Level + 1);
  341.         Left  = InptPrsrTypeCheck(Root -> Left,  Level + 1);
  342.         if (Right == ERROR_EXPR || Left == ERROR_EXPR)
  343.         return ERROR_EXPR;
  344.         if (!OverLoadTypeCheck(Root -> NodeKind, Right, Left, &Result)) {
  345.         IPGlblEvalError = IE_ERR_TYPE_MISMATCH;
  346.                 UpdateCharError("Operator ", Root -> NodeKind, Root);
  347.         return ERROR_EXPR;
  348.         }
  349.         else
  350.         return Result;
  351.     case UNARMINUS:
  352.         if ((Right = InptPrsrTypeCheck(Root -> Right, Level + 1))
  353.                             == ERROR_EXPR)
  354.         return ERROR_EXPR;
  355.         else if (!OverLoadTypeCheck(Root -> NodeKind, Right, NO_EXPR,
  356.                                 &Result)) {
  357.         IPGlblEvalError = IE_ERR_TYPE_MISMATCH;
  358.                 UpdateCharError("Operator ", Root -> NodeKind, Root);
  359.         return ERROR_EXPR;
  360.         }
  361.         else
  362.         return Result;
  363.     case EQUAL:
  364.         if ((Right = InptPrsrTypeCheck(Root -> Right, Level + 1))
  365.                             == ERROR_EXPR)
  366.         return ERROR_EXPR;
  367.         if (Root -> Left -> NodeKind != PARAMETER) {
  368.         IPGlblEvalError = IE_ERR_ASSIGN_LEFT_OP;
  369.         InptPrsrPrintTree(Root -> Left, IPGlblCharData);
  370.         return ERROR_EXPR;
  371.         }
  372.         else if (Root -> Left -> PObj -> ObjType == IP_OBJ_UNDEF)
  373.         SET_TO_BE_ASSIGN_OBJ(Root -> Left -> PObj);
  374.         return Right;
  375.     case BOOL_AND:
  376.     case BOOL_OR:
  377.         if (InptPrsrTypeCheck(Root -> Right, Level + 1) != NUMERIC_EXPR ||
  378.         InptPrsrTypeCheck(Root -> Left,  Level + 1) != NUMERIC_EXPR)
  379.         return ERROR_EXPR;
  380.         return NUMERIC_EXPR;
  381.     case BOOL_NOT:
  382.         if (InptPrsrTypeCheck(Root -> Right, Level + 1) != NUMERIC_EXPR)
  383.         return ERROR_EXPR;
  384.         return NUMERIC_EXPR;
  385.     case CMP_EQUAL:
  386.     case CMP_NOTEQUAL:
  387.     case CMP_LSEQUAL:
  388.     case CMP_GTEQUAL:
  389.     case CMP_LESS:
  390.     case CMP_GREAT:
  391.         Right = InptPrsrTypeCheck(Root -> Right, Level + 1);
  392.         Left  = InptPrsrTypeCheck(Root -> Left,  Level + 1);
  393.         if (Right == ERROR_EXPR || Left == ERROR_EXPR)
  394.         return ERROR_EXPR;
  395.         return NUMERIC_EXPR;
  396.     case NUMBER:
  397.         return NUMERIC_EXPR;
  398.     case PARAMETER:
  399.         switch (Root -> PObj -> ObjType) {
  400.                 case IP_OBJ_POLY:
  401.                     return POLY_EXPR;
  402.         case IP_OBJ_NUMERIC:
  403.             return NUMERIC_EXPR;
  404.         case IP_OBJ_POINT:
  405.             return POINT_EXPR;
  406.         case IP_OBJ_VECTOR:
  407.             return VECTOR_EXPR;
  408.         case IP_OBJ_PLANE:
  409.             return PLANE_EXPR;
  410.         case IP_OBJ_CTLPT:
  411.             return CTLPT_EXPR;
  412.         case IP_OBJ_MATRIX:
  413.             return MATRIX_EXPR;
  414.         case IP_OBJ_STRING:
  415.             return STRING_EXPR;
  416.         case IP_OBJ_LIST_OBJ:
  417.             return OLST_EXPR;
  418.         case IP_OBJ_CURVE:
  419.             return CURVE_EXPR;
  420.         case IP_OBJ_SURFACE:
  421.             return SURFACE_EXPR;
  422.         default:
  423.             if (IS_TO_BE_ASSIGN_OBJ(Root -> PObj)) {
  424.             /* A block of expressions seperated by colons has  */
  425.             /* an assignment followed by usage herein. No idea */
  426.             /* of the type forces us to allow anything and     */
  427.             /* hope for the best.                   */
  428.             return ANY_EXPR;
  429.             }
  430.             else {
  431.             IPGlblEvalError = IE_ERR_IP_OBJ_UNDEFINED;
  432.             sprintf(IPGlblCharData, "Object = %s, Type %d",
  433.                 Root -> PObj -> Name, Root -> PObj -> ObjType);
  434.             return ERROR_EXPR;
  435.             }
  436.         }
  437.     case STRING:
  438.         return STRING_EXPR;
  439.     case USERFUNCDEF:
  440.         return ANY_EXPR;
  441.     case USERPROCDEF:
  442.         return NO_EXPR;
  443.     case USERINSTDEF:
  444.         return ANY_EXPR;
  445.     case COLON:
  446.         if (Root -> Left &&
  447.         Root -> Left -> NodeKind == EQUAL &&
  448.         Root -> Left -> Right &&
  449.         (Root -> Left-> Right -> NodeKind == USERPROCDEF ||
  450.          Root -> Left-> Right -> NodeKind == USERFUNCDEF)) {
  451.         ParseTree *Body;
  452.  
  453.         /* A special form of function/procedure definition. */
  454.         for (Body = Root;
  455.              Body -> NodeKind == COLON;
  456.              Body = Body -> Right);
  457.         if (Root -> Left -> Left -> NodeKind != PARAMETER ||
  458.             Body == NULL ||
  459.             Body == Root)
  460.             return ERROR_EXPR;            
  461.         }
  462.         else {
  463.         Left  = InptPrsrTypeCheck(Root -> Left,  0);
  464.         Right = InptPrsrTypeCheck(Root -> Right, 0);
  465.         if (Right == ERROR_EXPR || Left == ERROR_EXPR)
  466.             return ERROR_EXPR;
  467.         }
  468.         return NO_EXPR;
  469.     default:                     /* Should never happen. */
  470.         IPGlblEvalError = IE_ERR_FATAL_ERROR;
  471.             UpdateCharError("Token ", Root -> NodeKind, Root);
  472.         return ERROR_EXPR;
  473.     }
  474. }
  475.  
  476. /* Disable the function with no prototype warning on Borland's compilers. */
  477. #ifdef __BORLANDC__
  478. #pragma warn -pro
  479. #endif /* __BORLANDC__ */
  480.  
  481. /*****************************************************************************
  482. * DESCRIPTION:                                                               M
  483. * Evaluates the given parsed and verified tree (via InptPrsrTypeCheck rtn).  M
  484. *    The tree is modified, in place, during the evaluation process.         M
  485. *                                                                            *
  486. * PARAMETERS:                                                                M
  487. *   Root:      Parsed tree to evaluate.                                      M
  488. *   Level:     Of recursion. Used to identify top level (Level == 0).        M
  489. *                                                                            *
  490. * RETURN VALUE:                                                              M
  491. *   ParseTree *:   Result of evaluation.                                     M
  492. *                                                                            *
  493. * KEYWORDS:                                                                  M
  494. *   InptPrsrEvalTree                                                         M
  495. *****************************************************************************/
  496. ParseTree *InptPrsrEvalTree(ParseTree *Root, int Level)
  497. {
  498.     int Index, NumOfParam,
  499.     PrintIt = (Level == 0 && Root -> NodeKind != EQUAL);
  500.     char *ErrorMsg, *p, Name[LINE_LEN];
  501.     ParseTree *TempL, *TempR, *Params[FUNC_MAX_PARAM],
  502.     *RetVal = NULL;
  503.     VoidPtr ParamPtrs[FUNC_MAX_PARAM];
  504.  
  505.     if (IS_NUM_FUNCTION(Root -> NodeKind)) {/* Funcs which return Real Type: */
  506.     Index = Root -> NodeKind - NUM_FUNC_OFFSET;
  507.     NumOfParam = NumFuncTable[Index].NumOfParam;
  508.  
  509.     switch(Root -> NodeKind) {
  510.         case ARCSIN:   /* Real return functions with one real parameter. */
  511.         case ARCCOS:
  512.         case ARCTAN:
  513.         case COS:
  514.         case EXP:
  515.         case FABS:
  516.         case LN:
  517.         case LOG:
  518.         case SIN:
  519.         case SQRT:
  520.         case TAN:
  521.         case TIME:
  522.         if (InptEvalFetchParameters(Root, NULL, 1, Level,
  523.                         Params, ParamPtrs) != 1)
  524.             break;
  525.         /* Use table entries to call the function directly. */
  526.         Root -> PObj =
  527.             GenNUMValObject((NumFuncTable[Index].Func)
  528.                         (Params[0] -> PObj -> U.R));
  529.         RetVal = Root;
  530.         break;
  531.  
  532.         case ARCTAN2:
  533.         case IRT_RNDM:
  534.         if (InptEvalFetchParameters(Root, NULL, 2, Level,
  535.                         Params, ParamPtrs) != 2)
  536.             break;
  537.         /* Use table entries to call the function directly. */
  538.         Root -> PObj =
  539.             GenNUMValObject((NumFuncTable[Index].Func)
  540.                         (Params[0] -> PObj -> U.R,
  541.                      Params[1] -> PObj -> U.R));
  542.         RetVal = Root;
  543.         break;
  544.  
  545.         default:
  546.         if (InptEvalFetchParameters(Root,
  547.             (FuncTableType *) &NumFuncTable[Index],
  548.             NumOfParam, Level, Params, ParamPtrs) != NumOfParam)
  549.             break;
  550.  
  551.         /* Use table entries to call the function directly. */
  552.         switch (NumFuncTable[Index].NumOfParam) {
  553.             case 0:
  554.                 Root -> PObj =
  555.                 GenNUMValObject((NumFuncTable[Index].Func)());
  556.             break;
  557.             case 1:
  558.                 Root -> PObj =
  559.                 GenNUMValObject((NumFuncTable[Index].Func)
  560.                             (ParamPtrs[0]));
  561.             break;
  562.             case 2:
  563.             Root -> PObj =
  564.                 GenNUMValObject((NumFuncTable[Index].Func)
  565.                             (ParamPtrs[0], ParamPtrs[1]));
  566.             break;
  567.             case 3:
  568.             Root -> PObj =
  569.                 GenNUMValObject((NumFuncTable[Index].Func)
  570.                             (ParamPtrs[0], ParamPtrs[1],
  571.                          ParamPtrs[2]));
  572.             break;
  573.             case 4:
  574.             Root -> PObj =
  575.                 GenNUMValObject((NumFuncTable[Index].Func)
  576.                             (ParamPtrs[0], ParamPtrs[1],
  577.                          ParamPtrs[2], ParamPtrs[3]));
  578.                 break;
  579.             case 5:
  580.                 Root -> PObj =
  581.                 GenNUMValObject((NumFuncTable[Index].Func)
  582.                             (ParamPtrs[0], ParamPtrs[1],
  583.                          ParamPtrs[2], ParamPtrs[3],
  584.                          ParamPtrs[4]));
  585.                 break;
  586.             case 6:
  587.                 Root -> PObj =
  588.                 GenNUMValObject((NumFuncTable[Index].Func)
  589.                             (ParamPtrs[0], ParamPtrs[1],
  590.                          ParamPtrs[2], ParamPtrs[3],
  591.                          ParamPtrs[4], ParamPtrs[5]));
  592.                 break;
  593.         }
  594.  
  595.         RetVal = Root;
  596.         break;
  597.     }
  598.     }
  599.     else if (IS_OBJ_FUNCTION(Root -> NodeKind)) {/* Funcs returning objects: */
  600.     Index = Root -> NodeKind - OBJ_FUNC_OFFSET;
  601.     NumOfParam = ObjFuncTable[Index].NumOfParam;
  602.  
  603.     switch (Root -> NodeKind) {
  604.         case COORD:
  605.             if (InptEvalFetchParameters(Root, NULL, 2, Level,
  606.                         Params, ParamPtrs) != 2)
  607.             break;
  608.             /* Use table entries to call the function directly. */
  609.         Root -> PObj =
  610.             (ObjFuncTable[Index].Func)
  611.                 (Params[0] -> PObj, &Params[1] -> PObj -> U.R);
  612.         if (Root -> PObj == NULL)
  613.             break;
  614.  
  615.         RetVal = Root;
  616.         break;
  617.  
  618.         case NTH:
  619.         if (InptEvalFetchParameters(Root, NULL, 2,
  620.                         Level, Params, ParamPtrs) != 2)
  621.             break;
  622.         /* Use table entries to call the function directly. */
  623.         Root -> PObj =
  624.             (ObjFuncTable[Index].Func)
  625.                 (Params[0] -> PObj, &Params[1] -> PObj -> U.R);
  626.         if (Root -> PObj == NULL)
  627.             break;
  628.  
  629.         RetVal = Root;
  630.         break;
  631.  
  632.         case LOAD:
  633.         if (InptEvalFetchParameters(Root, NULL, 1,
  634.                         Level, Params, ParamPtrs) != 1)
  635.             break;
  636.         /* Use table entries to call the function directly. */
  637.         Root -> PObj =
  638.             (ObjFuncTable[Index].Func)(Params[0] -> PObj -> U.Str, "");
  639.         if (Root -> PObj == NULL) {
  640.                 LoadSaveObjectParseError(&ErrorMsg);
  641.             IPGlblEvalError = IE_ERR_DATA_PRSR_ERROR;
  642.             strcpy(IPGlblCharData, ErrorMsg);
  643.             break;
  644.         }
  645.         RetVal = Root;
  646.         break;
  647.  
  648.         case CTLPT:
  649.         case LIST:
  650.         /* Use table entries to call the function directly. */
  651.         Root -> PObj = (ObjFuncTable[Index].Func)(Root -> Right);
  652.         if (Root -> PObj == NULL)
  653.             break;
  654.         RetVal = Root;
  655.         break;
  656.  
  657.         default:
  658.         if (InptEvalFetchParameters(Root,
  659.             (FuncTableType *) &ObjFuncTable[Index],
  660.             NumOfParam, Level, Params, ParamPtrs) != NumOfParam)
  661.             break;
  662.  
  663.         /* Use table entries to call the function directly. */
  664.         switch (ObjFuncTable[Index].NumOfParam) {
  665.             case 0:
  666.             Root -> PObj = (ObjFuncTable[Index].Func)();
  667.             break;
  668.             case 1:
  669.             Root -> PObj = (ObjFuncTable[Index].Func)
  670.                 (ParamPtrs[0]);
  671.             break;
  672.             case 2:
  673.             Root -> PObj = (ObjFuncTable[Index].Func)
  674.                 (ParamPtrs[0], ParamPtrs[1]);
  675.             break;
  676.             case 3:
  677.             Root -> PObj = (ObjFuncTable[Index].Func)
  678.                 (ParamPtrs[0], ParamPtrs[1], ParamPtrs[2]);
  679.             break;
  680.             case 4:
  681.             Root -> PObj = (ObjFuncTable[Index].Func)
  682.                 (ParamPtrs[0], ParamPtrs[1], ParamPtrs[2],
  683.                  ParamPtrs[3]);
  684.             break;
  685.             case 5:
  686.             Root -> PObj = (ObjFuncTable[Index].Func)
  687.                 (ParamPtrs[0], ParamPtrs[1], ParamPtrs[2],
  688.                  ParamPtrs[3], ParamPtrs[4]);
  689.             break;
  690.             case 6:
  691.             Root -> PObj = (ObjFuncTable[Index].Func)
  692.                 (ParamPtrs[0], ParamPtrs[1], ParamPtrs[2],
  693.                  ParamPtrs[3], ParamPtrs[4], ParamPtrs[5]);
  694.             break;
  695.         }
  696.         if (Root -> PObj == NULL)
  697.             break;
  698.         RetVal = Root;
  699.         break;
  700.     }
  701.     }
  702.     else if (IS_GEN_FUNCTION(Root -> NodeKind)) {/* Funcs returning nothing: */
  703.     Index = Root -> NodeKind - GEN_FUNC_OFFSET;
  704.     NumOfParam = GenFuncTable[Index].NumOfParam;
  705.  
  706.     switch (Root -> NodeKind) {
  707.         case COLOR:
  708.         if (InptEvalFetchParameters(Root, NULL, 2, Level,
  709.                         Params, ParamPtrs) != 2)
  710.             break;
  711.  
  712.         (GenFuncTable[Index].Func)
  713.              (Params[0] -> PObj,
  714.               REAL_TO_INT(Params[1] -> PObj -> U.R));
  715.         break;
  716.     
  717.         case VARLIST:
  718.             (GenFuncTable[Index].Func)(GlblObjList);
  719.         break;
  720.  
  721.         case SAVE:
  722.         if (InptEvalFetchParameters(Root, NULL, 2, Level,
  723.                         Params, ParamPtrs) != 2)
  724.             break;
  725.  
  726.         /* Use table entries to call the function directly. */
  727.         (GenFuncTable[Index].Func)(Params[0] -> PObj -> U.Str,
  728.                        Params[1] -> PObj);
  729.  
  730.         /* Save the matrix. */
  731.         strncpy(Name, Params[0] -> PObj -> U.Str, LINE_LEN - 5);
  732.         if ((p = strstr(Name, ".dat")) != NULL ||
  733.             (p = strstr(Name, ".DAT")) != NULL)
  734.             *p = 0;
  735.         strcat(Name, ".mat");
  736.         WndwViewSaveMatrix(Name);
  737.  
  738.             if (LoadSaveObjectParseError(&ErrorMsg) != 0) {
  739.             IPGlblEvalError = IE_ERR_DATA_PRSR_ERROR;
  740.             strcpy(IPGlblCharData, ErrorMsg);
  741.             break;
  742.             }
  743.         break;
  744.  
  745.         case FREEOBJ:
  746.         if (InptEvalFetchParameters(Root, NULL, 1, Level, Params,
  747.                         ParamPtrs) != 1 ||
  748.                 (TempR = InptPrsrEvalTree(Root -> Right, Level + 1))
  749.                                    == NULL)
  750.             break;
  751.  
  752.             if (strlen(TempR -> PObj -> Name) == 0) {
  753.             IPGlblEvalError = IE_ERR_FREE_SIMPLE;
  754.                     UpdateCharError("Procedure ", FREEOBJ, NULL);
  755.             RetVal = Root;
  756.             break;
  757.             }
  758.             /* Use table entries to call the function directly. */
  759.             (GenFuncTable[Index].Func)(TempR -> PObj);
  760.             TempR -> PObj = NULL;        /* Make sure its disconnected... */
  761.         break;
  762.  
  763.         case IFCOND:
  764.         switch (NumOfParam =
  765.                       InptEvalCountNumParameters(Root -> Right)) {
  766.             case 2:
  767.             InptEvalIfCondition(
  768.                 InptEvalFetchParameter(Root -> Right, 0, 2),
  769.                 InptEvalFetchParameter(Root -> Right, 1, 2),
  770.                 NULL);
  771.             break;
  772.             case 3:
  773.             InptEvalIfCondition(
  774.                 InptEvalFetchParameter(Root -> Right, 0, 3),
  775.                 InptEvalFetchParameter(Root -> Right, 1, 3),
  776.                 InptEvalFetchParameter(Root -> Right, 2, 3));
  777.             break;
  778.             default:
  779.             IPGlblEvalError = IE_ERR_NUM_PRM_MISMATCH;
  780.             sprintf(IPGlblCharData,
  781.                 "IF clause (2 or 3 expected, found %d)",
  782.                 NumOfParam);
  783.             break;
  784.         }
  785.         break;
  786.  
  787.         case FORLOOP:
  788.         InptEvalForLoop(InptEvalFetchParameter(Root -> Right, 0, 4),
  789.                 InptEvalFetchParameter(Root -> Right, 1, 4),
  790.                 InptEvalFetchParameter(Root -> Right, 2, 4),
  791.                 InptEvalFetchParameter(Root -> Right, 3, 4));
  792.         break;
  793.  
  794.         default:
  795.         if (InptEvalFetchParameters(Root,
  796.             (FuncTableType *) &GenFuncTable[Index],
  797.             NumOfParam, Level, Params, ParamPtrs) != NumOfParam)
  798.             break;
  799.  
  800.         /* Use table entries to call the function directly. */
  801.         switch (GenFuncTable[Index].NumOfParam) {
  802.             case 0:
  803.             (GenFuncTable[Index].Func)();
  804.             break;
  805.             case 1:
  806.             (GenFuncTable[Index].Func)
  807.                 (ParamPtrs[0]);
  808.             break;
  809.             case 2:
  810.             (GenFuncTable[Index].Func)
  811.                 (ParamPtrs[0], ParamPtrs[1]);
  812.             break;
  813.             case 3:
  814.             (GenFuncTable[Index].Func)
  815.                 (ParamPtrs[0], ParamPtrs[1], ParamPtrs[2]);
  816.             break;
  817.             case 4:
  818.             (GenFuncTable[Index].Func)
  819.                 (ParamPtrs[0], ParamPtrs[1], ParamPtrs[2],
  820.                  ParamPtrs[3]);
  821.             break;
  822.             case 5:
  823.             (GenFuncTable[Index].Func)
  824.                 (ParamPtrs[0], ParamPtrs[1], ParamPtrs[2],
  825.                  ParamPtrs[3], ParamPtrs[4]);
  826.             break;
  827.             case 6:
  828.             (GenFuncTable[Index].Func)
  829.                 (ParamPtrs[0], ParamPtrs[1], ParamPtrs[2],
  830.                  ParamPtrs[3], ParamPtrs[4], ParamPtrs[5]);
  831.             break;
  832.         }
  833.         break;
  834.     }
  835.     RetVal = Root;
  836.     if (Root -> PObj)
  837.         Root -> PObj -> ObjType = IP_OBJ_UNDEF;
  838.     else
  839.         Root -> PObj = IPAllocObject("", IP_OBJ_UNDEF, NULL);
  840.     }
  841.     else {
  842.         switch (Root -> NodeKind) {          /* The rest of the world. */
  843.         case PLUS:
  844.         case MINUS:
  845.         case MULT:
  846.         case DIV:
  847.         case POWER:
  848.             if (((TempR = InptPrsrEvalTree(Root -> Right, Level + 1))
  849.                                 == NULL) ||
  850.             ((TempL = InptPrsrEvalTree(Root -> Left,  Level + 1))
  851.                                 == NULL))
  852.             break;
  853.         TempR = OverLoadEvalOper(Root, TempR, TempL,
  854.                      &IPGlblEvalError, IPGlblCharData);
  855.         RetVal = TempR;
  856.         break;
  857.  
  858.         case UNARMINUS:
  859.         if ((TempR = InptPrsrEvalTree(Root -> Right, Level + 1))
  860.                                       == NULL)
  861.             break;
  862.         TempR = OverLoadEvalOper(Root, TempR, NULL,
  863.                      &IPGlblEvalError, IPGlblCharData);
  864.         RetVal = TempR;
  865.         break;
  866.  
  867.         case COLON:
  868.         if (Root -> Left &&
  869.             Root -> Left -> NodeKind == EQUAL &&
  870.             Root -> Left -> Right &&
  871.             (Root -> Left-> Right -> NodeKind == USERPROCDEF ||
  872.              Root -> Left-> Right -> NodeKind == USERFUNCDEF)) {
  873.             /* A special form of function/procedure definition. */
  874.             InptEvalDefineFunc(Root);
  875.         }
  876.         else {
  877.             InptPrsrEvalTree(Root -> Left, 0);
  878.             InptPrsrEvalTree(Root -> Right, 0);
  879.         }
  880.         break;
  881.  
  882.         case NUMBER:
  883.         RetVal = Root;
  884.         break;
  885.  
  886.         case PARAMETER:
  887.         RetVal = Root;
  888.         break;
  889.  
  890.         case STRING:
  891.         RetVal = Root;
  892.         break;
  893.  
  894.         case EQUAL:
  895.         if ((TempR = InptPrsrEvalTree(Root -> Right, Level + 1))
  896.                                 == NULL)
  897.             break;
  898.         TempL = Root -> Left;
  899.  
  900.         if (TempL -> PObj == TempR -> PObj) {
  901.             RetVal = TempR; /* A = A. */
  902.             break;
  903.         }
  904.         else if (TempL -> PObj == NULL)
  905.             TempL -> PObj = IPAllocObject("", IP_OBJ_UNDEF, NULL);
  906.         else if (ListObjectFind(TempR -> PObj, TempL -> PObj)) {
  907.             /* Object is in the list. To prevent a loop in the list */
  908.             /* structure, create a new object to hold the result.   */
  909.             strcpy(Name, TempL -> PObj -> Name);
  910.             DeleteObject(TempL -> PObj, FALSE);
  911.             TempL -> PObj -> Count -= 2;
  912.             TempL -> PObj -> Name[0] = 0;
  913.  
  914.             TempL -> PObj = IPAllocObject(Name, IP_OBJ_UNDEF, NULL);
  915.             InsertObject(TempL -> PObj);
  916.             TempL -> PObj -> Count++;
  917.         }
  918.         CopyObject(TempL -> PObj, TempR -> PObj, FALSE);
  919.  
  920.         RetVal = TempR;
  921.         break;
  922.  
  923.         case BOOL_AND:
  924.             if (((TempR = InptPrsrEvalTree(Root -> Right, Level + 1))
  925.                                 == NULL) ||
  926.             ((TempL = InptPrsrEvalTree(Root -> Left,  Level + 1))
  927.                                 == NULL))
  928.             break;
  929.         if (Root -> PObj)
  930.             Root -> PObj -> ObjType = IP_OBJ_NUMERIC;
  931.         else
  932.             Root -> PObj = IPAllocObject("", IP_OBJ_NUMERIC, NULL);
  933.         Root -> PObj -> ObjType = IP_OBJ_NUMERIC;
  934.         Root -> PObj -> U.R = (!APX_EQ(TempR -> PObj -> U.R, 0.0) &&
  935.                        !APX_EQ(TempL -> PObj -> U.R, 0.0));
  936.         RetVal = Root;
  937.         break;
  938.  
  939.         case BOOL_OR:
  940.             if (((TempR = InptPrsrEvalTree(Root -> Right, Level + 1))
  941.                                 == NULL) ||
  942.             ((TempL = InptPrsrEvalTree(Root -> Left,  Level + 1))
  943.                                 == NULL))
  944.             break;
  945.         if (Root -> PObj)
  946.             Root -> PObj -> ObjType = IP_OBJ_NUMERIC;
  947.         else
  948.             Root -> PObj = IPAllocObject("", IP_OBJ_NUMERIC, NULL);
  949.         Root -> PObj -> U.R = (!APX_EQ(TempR -> PObj -> U.R, 0.0) ||
  950.                        !APX_EQ(TempL -> PObj -> U.R, 0.0));
  951.         RetVal = Root;
  952.         break;
  953.  
  954.         case BOOL_NOT:
  955.         if ((TempR = InptPrsrEvalTree(Root -> Right, Level + 1))
  956.                                       == NULL)
  957.             break;
  958.         if (Root -> PObj)
  959.             Root -> PObj -> ObjType = IP_OBJ_NUMERIC;
  960.         else
  961.             Root -> PObj = IPAllocObject("", IP_OBJ_NUMERIC, NULL);
  962.         Root -> PObj -> U.R = APX_EQ(TempR -> PObj -> U.R, 0.0);
  963.         RetVal = Root;
  964.         break;
  965.  
  966.         case CMP_EQUAL:
  967.         case CMP_NOTEQUAL:
  968.         case CMP_LSEQUAL:
  969.         case CMP_GTEQUAL:
  970.         case CMP_LESS:
  971.         case CMP_GREAT:
  972.             if (((TempR = InptPrsrEvalTree(Root -> Right, Level + 1))
  973.                                 == NULL) ||
  974.             ((TempL = InptPrsrEvalTree(Root -> Left,  Level + 1))
  975.                                 == NULL))
  976.             break;
  977.         RetVal = InptEvalCompareObject(Root, TempL, TempR,
  978.                        &IPGlblEvalError, IPGlblCharData);
  979.         break;
  980.  
  981.         case USERINSTDEF:
  982.         if (InptEvalCountNumParameters(Root -> Right) !=
  983.             Root -> UserFunc -> NumParams) {
  984.             IPGlblEvalError = IE_ERR_NUM_PRM_MISMATCH;
  985.             strcpy(IPGlblCharData, Root -> UserFunc -> FuncName);
  986.             break;
  987.         }
  988.         if (InptEvalFetchParameters(Root, NULL,
  989.             Root -> UserFunc -> NumParams,
  990.             Level, Params, ParamPtrs) !=
  991.             Root -> UserFunc -> NumParams)
  992.             break;
  993.  
  994.         RetVal = InptEvalUserFunc(Root, Params);
  995.         break;
  996.     }
  997.     }
  998.  
  999.     if (PrintIt &&
  1000.     RetVal &&
  1001.     RetVal -> PObj &&
  1002.     RetVal -> PObj -> ObjType != IP_OBJ_UNDEF) {
  1003.     RetVal -> PObj -> Count--;           /* Remove ref from this tree. */
  1004.     PrintObject(RetVal -> PObj);
  1005.     RetVal -> PObj -> Count++;              /* Add reference back. */
  1006.     }
  1007.  
  1008.     return RetVal;
  1009. }
  1010.  
  1011. /* Restore the function with no prototype warning on Borland's compilers. */
  1012. #ifdef __BORLANDC__
  1013. #pragma warn .pro
  1014. #endif /* __BORLANDC__ */
  1015.